from flask import jsonify
from ..models import db, Song, Artist, ArtistSong, Admin
from sqlalchemy.exc import SQLAlchemyError
import logging

logger = logging.getLogger(__name__)

class Repository:
    """资源库类，提供歌曲和歌手的查询和导入功能"""
    
    @staticmethod
    def get_songs(page=1, per_page=20, filters=None):
        """
        获取歌曲库
        
        Args:
            page: 页码
            per_page: 每页数量
            filters: 过滤条件，字典类型，例如 {'song_name': '歌曲名', 'artist_name': '歌手名', 'style_name': '风格名'}
            
        Returns:
            dict: 包含歌曲列表和分页信息
        """
        try:
            query = Song.query
            
            # 应用过滤条件
            if filters:
                if 'song_name' in filters and filters['song_name']:
                    query = query.filter(Song.song_name.like(f'%{filters["song_name"]}%'))
                
                if 'artist_name' in filters and filters['artist_name']:
                    query = query.join(ArtistSong).join(Artist).filter(
                        Artist.artist_name.like(f'%{filters["artist_name"]}%')
                    )
                
                # 移除风格过滤，因为数据库中没有风格表
                # if 'style_name' in filters and filters['style_name']:
                #     query = query.join(SongStyle).join(Style).filter(
                #         Style.style_name.like(f'%{filters["style_name"]}%')
                #     )
            
            # 分页
            pagination = query.paginate(page=page, per_page=per_page, error_out=False)
            songs = pagination.items
            
            result = {
                'total': pagination.total,
                'pages': pagination.pages,
                'current_page': page,
                'per_page': per_page,
                'songs': []
            }
            
            for song in songs:
                song_data = {
                    'id': song.id,
                    'song_id': song.song_id,
                    'song_name': song.song_name,
                    'song_duration': song.song_duration,
                    'artists': [{'artist_id': artist.artist_id, 'artist_name': artist.artist_name} 
                               for artist in song.artists]
                    # 移除风格，因为数据库中没有风格表
                    # 'styles': [{'style_id': style.style_id, 'style_name': style.style_name} 
                    #           for style in song.styles]
                }
                result['songs'].append(song_data)
            
            return {'code': 200, 'data': result, 'message': '获取歌曲列表成功'}
        
        except SQLAlchemyError as e:
            logger.error(f"获取歌曲列表失败: {str(e)}")
            return {'code': 500, 'message': f'获取歌曲列表失败: {str(e)}'}
    
    @staticmethod
    def get_artists(page=1, per_page=20, name_filter=None):
        """
        获取歌手库
        
        Args:
            page: 页码
            per_page: 每页数量
            name_filter: 歌手名称过滤
            
        Returns:
            dict: 包含歌手列表和分页信息
        """
        try:
            query = Artist.query
            
            # 应用过滤条件
            if name_filter:
                query = query.filter(Artist.artist_name.like(f'%{name_filter}%'))
            
            # 分页
            pagination = query.paginate(page=page, per_page=per_page, error_out=False)
            artists = pagination.items
            
            result = {
                'total': pagination.total,
                'pages': pagination.pages,
                'current_page': page,
                'per_page': per_page,
                'artists': []
            }
            
            for artist in artists:
                artist_data = {
                    'artist_id': artist.artist_id,
                    'artist_name': artist.artist_name,
                    'songs_count': len(artist.songs)
                }
                result['artists'].append(artist_data)
            
            return {'code': 200, 'data': result, 'message': '获取歌手列表成功'}
        
        except SQLAlchemyError as e:
            logger.error(f"获取歌手列表失败: {str(e)}")
            return {'code': 500, 'message': f'获取歌手列表失败: {str(e)}'}
    
    @staticmethod
    def import_song(song_data):
        """
        导入歌曲
        
        Args:
            song_data: 歌曲数据，字典类型，包含:
                - song_name: 歌曲名称
                - song_duration: 歌曲时长(秒)
                - artists: 歌手ID列表
                
        Returns:
            dict: 操作结果
        """
        try:
            # 验证必要参数
            if not all(key in song_data for key in ['song_name', 'song_duration']):
                return {'code': 400, 'message': '缺少必要参数'}
            
            # 创建歌曲
            new_song = Song(
                song_name=song_data['song_name'],
                song_duration=song_data['song_duration']
            )
            
            db.session.add(new_song)
            db.session.flush()  # 获取新插入记录的ID
            
            # 添加歌手关联
            if 'artists' in song_data and song_data['artists']:
                for artist_id in song_data['artists']:
                    artist = Artist.query.get(artist_id)
                    if artist:
                        artist_song = ArtistSong(artist_id=artist_id, song_id=new_song.song_id)
                        db.session.add(artist_song)
            
            # 移除风格关联，因为数据库中没有风格表
            # if 'styles' in song_data and song_data['styles']:
            #     for style_id in song_data['styles']:
            #         style = Style.query.get(style_id)
            #         if style:
            #             song_style = SongStyle(song_id=new_song.song_id, style_id=style_id)
            #             db.session.add(song_style)
            
            db.session.commit()
            return {'code': 200, 'data': {'song_id': new_song.song_id}, 'message': '歌曲导入成功'}
        
        except SQLAlchemyError as e:
            db.session.rollback()
            logger.error(f"歌曲导入失败: {str(e)}")
            return {'code': 500, 'message': f'歌曲导入失败: {str(e)}'}
    
    @staticmethod
    def import_artist(artist_data):
        """
        导入歌手
        
        Args:
            artist_data: 歌手数据，字典类型，包含:
                - artist_name: 歌手名称
                
        Returns:
            dict: 操作结果
        """
        try:
            # 验证必要参数
            if 'artist_name' not in artist_data:
                return {'code': 400, 'message': '缺少必要参数: artist_name'}
            
            # 检查歌手是否已存在
            existing_artist = Artist.query.filter_by(artist_name=artist_data['artist_name']).first()
            if existing_artist:
                return {'code': 409, 'message': '歌手已存在', 'data': {'artist_id': existing_artist.artist_id}}
            
            # 创建歌手
            new_artist = Artist(artist_name=artist_data['artist_name'])
            
            db.session.add(new_artist)
            db.session.commit()
            
            return {'code': 200, 'data': {'artist_id': new_artist.artist_id}, 'message': '歌手导入成功'}
        
        except SQLAlchemyError as e:
            db.session.rollback()
            logger.error(f"歌手导入失败: {str(e)}")
            return {'code': 500, 'message': f'歌手导入失败: {str(e)}'}
    
    @staticmethod
    def get_song_details(song_id):
        """
        获取歌曲详情
        
        Args:
            song_id: 歌曲ID
            
        Returns:
            dict: 歌曲详情
        """
        try:
            song = Song.query.get(song_id)
            
            if not song:
                return {'code': 404, 'message': '歌曲不存在'}
            
            song_data = {
                'id': song.id,
                'song_id': song.song_id,
                'song_name': song.song_name,
                'song_duration': song.song_duration,
                'artists': [{'artist_id': artist.artist_id, 'artist_name': artist.artist_name} 
                           for artist in song.artists]
                # 移除风格，因为数据库中没有风格表
                # 'styles': [{'style_id': style.style_id, 'style_name': style.style_name} 
                #           for style in song.styles]
            }
            
            return {'code': 200, 'data': song_data, 'message': '获取歌曲详情成功'}
        
        except SQLAlchemyError as e:
            logger.error(f"获取歌曲详情失败: {str(e)}")
            return {'code': 500, 'message': f'获取歌曲详情失败: {str(e)}'}
    
    @staticmethod
    def get_artist_details(artist_id):
        """
        获取歌手详情
        
        Args:
            artist_id: 歌手ID
            
        Returns:
            dict: 歌手详情
        """
        try:
            artist = Artist.query.get(artist_id)
            
            if not artist:
                return {'code': 404, 'message': '歌手不存在'}
            
            songs = []
            for song in artist.songs:
                song_data = {
                    'song_id': song.song_id,
                    'song_name': song.song_name,
                    'song_duration': song.song_duration
                }
                songs.append(song_data)
            
            artist_data = {
                'artist_id': artist.artist_id,
                'artist_name': artist.artist_name,
                'songs': songs
            }
            
            return {'code': 200, 'data': artist_data, 'message': '获取歌手详情成功'}
        
        except SQLAlchemyError as e:
            logger.error(f"获取歌手详情失败: {str(e)}")
            return {'code': 500, 'message': f'获取歌手详情失败: {str(e)}'}
    
    @staticmethod
    def get_admins(page=1, per_page=20, name_filter=None):
        """
        获取管理员账户列表
        
        Args:
            page: 页码
            per_page: 每页数量
            name_filter: 管理员名称过滤
            
        Returns:
            dict: 包含管理员列表和分页信息
        """
        try:
            query = Admin.query
            
            # 应用过滤条件
            if name_filter:
                query = query.filter(Admin.admin_name.like(f'%{name_filter}%'))
            
            # 分页
            pagination = query.paginate(page=page, per_page=per_page, error_out=False)
            admins = pagination.items
            
            result = {
                'total': pagination.total,
                'pages': pagination.pages,
                'current_page': page,
                'per_page': per_page,
                'admins': []
            }
            
            for admin in admins:
                admin_data = {
                    'admin_id': admin.admin_id,
                    'admin_name': admin.admin_name,
                    'admin_level': admin.admin_level,
                    'create_at': admin.create_at.strftime("%Y-%m-%d %H:%M:%S") if admin.create_at else None,
                    'last_login': admin.last_login.strftime("%Y-%m-%d %H:%M:%S") if admin.last_login else None,
                    'is_active': admin.is_active
                }
                result['admins'].append(admin_data)
            
            return {'code': 200, 'data': result, 'message': '获取管理员列表成功'}
        
        except SQLAlchemyError as e:
            logger.error(f"获取管理员列表失败: {str(e)}")
            return {'code': 500, 'message': f'获取管理员列表失败: {str(e)}'}
    
    # 移除get_styles方法，因为数据库中没有风格表
    # @staticmethod
    # def get_styles(page=1, per_page=20, name_filter=None):
    #    ...
 